home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / alpha68k.c < prev    next >
C/C++ Source or Header  |  2000-04-29  |  17KB  |  659 lines
  1. /***************************************************************************
  2.  
  3.    Alpha 68k video emulation - Bryan McPhail, mish@tendril.co.uk
  4.  
  5. ****************************************************************************/
  6.  
  7. #include "driver.h"
  8. #include "vidhrdw/generic.h"
  9.  
  10. static int bank_base,flipscreen;
  11. static struct tilemap *fix_tilemap;
  12.  
  13. /******************************************************************************/
  14.  
  15. WRITE_HANDLER( alpha68k_flipscreen_w )
  16. {
  17.     flipscreen=data&1;
  18. }
  19.  
  20. WRITE_HANDLER( alpha68k_V_video_bank_w )
  21. {
  22.     bank_base=data&0xf;
  23. }
  24.  
  25. WRITE_HANDLER( alpha68k_paletteram_w )
  26. {
  27.     int oldword = READ_WORD (&paletteram[offset]);
  28.     int newword = COMBINE_WORD (oldword, data);
  29.     int r,g,b;
  30.  
  31.     WRITE_WORD (&paletteram[offset], newword);
  32.  
  33.     r = ((newword >> 7) & 0x1e) | ((newword >> 14) & 0x01);
  34.     g = ((newword >> 3) & 0x1e) | ((newword >> 13) & 0x01);
  35.     b = ((newword << 1) & 0x1e) | ((newword >> 12) & 0x01);
  36.  
  37.     r = (r << 3) | (r >> 2);
  38.     g = (g << 3) | (g >> 2);
  39.     b = (b << 3) | (b >> 2);
  40.  
  41.     palette_change_color(offset / 2,r,g,b);
  42. }
  43.  
  44. /******************************************************************************/
  45.  
  46. static void get_tile_info(int tile_index)
  47. {
  48.     int tile=READ_WORD(&videoram[4*tile_index])&0xff;
  49.     int color=READ_WORD(&videoram[4*tile_index+2])&0xf;
  50.  
  51.     tile=tile | (bank_base<<8);
  52.  
  53.     SET_TILE_INFO(0,tile,color)
  54. }
  55.  
  56. WRITE_HANDLER( alpha68k_videoram_w )
  57. {
  58.     if ((data>>16)==0xff)
  59.         WRITE_WORD(&videoram[offset],(data>>8)&0xff);
  60.     else
  61.         WRITE_WORD(&videoram[offset],data);
  62.  
  63.     tilemap_mark_tile_dirty(fix_tilemap,offset/4);
  64. }
  65.  
  66. int alpha68k_vh_start(void)
  67. {
  68.     fix_tilemap = tilemap_create(get_tile_info,tilemap_scan_cols,TILEMAP_TRANSPARENT,8,8,32,32);
  69.  
  70.     if (!fix_tilemap)
  71.         return 1;
  72.  
  73.     fix_tilemap->transparent_pen = 0;
  74.  
  75.     return 0;
  76. }
  77.  
  78. /******************************************************************************/
  79.  
  80. static void draw_sprites(struct osd_bitmap *bitmap, int j, int pos)
  81. {
  82.     int offs,mx,my,color,tile,fx,fy,i;
  83.  
  84.     for (offs = pos; offs < pos+0x800; offs += 0x80 )
  85.     {
  86.         mx=READ_WORD(&spriteram[offs+4+(4*j)])<<1;
  87.         my=READ_WORD(&spriteram[offs+6+(4*j)]);
  88.         if (my&0x8000) mx++;
  89.  
  90.         mx=(mx+0x100)&0x1ff;
  91.         my=(my+0x100)&0x1ff;
  92.         mx-=0x100;
  93.         my-=0x100;
  94.         my=0x200 - my;
  95.         my-=0x200;
  96.  
  97.         if (flipscreen) {
  98.             mx=240-mx;
  99.             my=240-my;
  100.         }
  101.  
  102.         for (i=0; i<0x80; i+=4) {
  103.             tile=READ_WORD(&spriteram[offs+2+i+(0x1000*j)+0x1000]);
  104.             color=READ_WORD(&spriteram[offs+i+(0x1000*j)+0x1000])&0x7f;
  105.  
  106.             fy=tile&0x8000;
  107.             fx=tile&0x4000;
  108.             tile&=0x3fff;
  109.  
  110.             if (flipscreen) {
  111.                 if (fx) fx=0; else fx=1;
  112.                 if (fy) fy=0; else fy=1;
  113.             }
  114.  
  115.             if (color)
  116.                 drawgfx(bitmap,Machine->gfx[1],
  117.                     tile,
  118.                     color,
  119.                     fx,fy,
  120.                     mx,my,
  121.                     0,TRANSPARENCY_PEN,0);
  122.  
  123.             if (flipscreen)
  124.                 my=(my-16)&0x1ff;
  125.             else
  126.                 my=(my+16)&0x1ff;
  127.         }
  128.     }
  129. }
  130.  
  131. /******************************************************************************/
  132.  
  133. void alpha68k_II_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  134. {
  135.     static int last_bank=0;
  136.     int offs,color,i;
  137.     int colmask[0x80],code,pal_base;
  138.  
  139.     if (last_bank!=bank_base)
  140.         tilemap_mark_all_tiles_dirty(ALL_TILEMAPS);
  141.     last_bank=bank_base;
  142.     tilemap_set_flip(ALL_TILEMAPS,flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  143.     tilemap_update(fix_tilemap);
  144.  
  145.     /* Build the dynamic palette */
  146.     palette_init_used_colors();
  147.     pal_base = Machine->drv->gfxdecodeinfo[1].color_codes_start;
  148.     for (color = 0;color < 128;color++) colmask[color] = 0;
  149.     for (offs = 0x1000;offs <0x4000;offs += 4 )
  150.     {
  151.         color= READ_WORD(&spriteram[offs])&0x7f;
  152.         if (!color) continue;
  153.         code = READ_WORD(&spriteram[offs+2])&0x3fff;
  154.         colmask[color] |= Machine->gfx[1]->pen_usage[code];
  155.     }
  156.  
  157.     for (color = 1;color < 128;color++)
  158.     {
  159.         for (i = 1;i < 16;i++)
  160.         {
  161.             if (colmask[color] & (1 << i))
  162.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  163.         }
  164.     }
  165.  
  166.     palette_transparent_color=2047;
  167.     palette_used_colors[2047] = PALETTE_COLOR_USED;
  168.     if (palette_recalc())
  169.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  170.     fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  171.  
  172.     tilemap_render(ALL_TILEMAPS);
  173.     draw_sprites(bitmap,1,0x000);
  174.     draw_sprites(bitmap,1,0x800);
  175.     draw_sprites(bitmap,0,0x000);
  176.     draw_sprites(bitmap,0,0x800);
  177.     draw_sprites(bitmap,2,0x000);
  178.     draw_sprites(bitmap,2,0x800);
  179.     tilemap_draw(bitmap,fix_tilemap,0);
  180. }
  181.  
  182. /******************************************************************************/
  183.  
  184. /*
  185.     Video banking:
  186.  
  187.     Write to these locations in this order for correct bank:
  188.  
  189.     20 28 30 for Bank 0
  190.     60 28 30 for Bank 1
  191.     20 68 30 etc
  192.     60 68 30
  193.     20 28 70
  194.     60 28 70
  195.     20 68 70
  196.     60 68 70 for Bank 7
  197.  
  198.     Actual data values written don't matter!
  199.  
  200. */
  201.  
  202. WRITE_HANDLER( alpha68k_II_video_bank_w )
  203. {
  204.     static int buffer_28,buffer_60,buffer_68;
  205.  
  206.     switch (offset) {
  207.         case 0x20: /* Reset */
  208.             bank_base=buffer_28=buffer_60=buffer_68=0;
  209.             return;
  210.         case 0x28:
  211.             buffer_28=1;
  212.             return;
  213.         case 0x30:
  214.             if (buffer_68) {if (buffer_60) bank_base=3; else bank_base=2; }
  215.             if (buffer_28) {if (buffer_60) bank_base=1; else bank_base=0; }
  216.             return;
  217.         case 0x60:
  218.             bank_base=buffer_28=buffer_68=0;
  219.             buffer_60=1;
  220.             return;
  221.         case 0x68:
  222.             buffer_68=1;
  223.             return;
  224.         case 0x70:
  225.             if (buffer_68) {if (buffer_60) bank_base=7; else bank_base=6; }
  226.             if (buffer_28) {if (buffer_60) bank_base=5; else bank_base=4; }
  227.             return;
  228.         case 0x10: /* Graphics flags?  Not related to fix chars anyway */
  229.         case 0x18:
  230.         case 0x50:
  231.         case 0x58:
  232.             return;
  233.     }
  234.  
  235.     logerror("%04x \n",offset);
  236. }
  237.  
  238. /******************************************************************************/
  239.  
  240. WRITE_HANDLER( alpha68k_V_video_control_w )
  241. {
  242.     switch (offset) {
  243.         case 0x10: /* Graphics flags?  Not related to fix chars anyway */
  244.         case 0x18:
  245.         case 0x50:
  246.         case 0x58:
  247.             return;
  248.     }
  249. }
  250.  
  251. static void draw_sprites_V(struct osd_bitmap *bitmap, int j, int s, int e, int fx_mask, int fy_mask, int sprite_mask)
  252. {
  253.     int offs,mx,my,color,tile,fx,fy,i;
  254.  
  255.     for (offs = s; offs < e; offs += 0x80 )
  256.     {
  257.         mx=READ_WORD(&spriteram[offs+4+(4*j)])<<1;
  258.         my=READ_WORD(&spriteram[offs+6+(4*j)]);
  259.         if (my&0x8000) mx++;
  260.  
  261.         mx=(mx+0x100)&0x1ff;
  262.         my=(my+0x100)&0x1ff;
  263.         mx-=0x100;
  264.         my-=0x100;
  265.         my=0x200 - my;
  266.         my-=0x200;
  267.  
  268.         if (flipscreen) {
  269.             mx=240-mx;
  270.             my=240-my;
  271.         }
  272.  
  273.         for (i=0; i<0x80; i+=4) {
  274.             tile=READ_WORD(&spriteram[offs+2+i+(0x1000*j)+0x1000]);
  275.             color=READ_WORD(&spriteram[offs+i+(0x1000*j)+0x1000])&0xff;
  276.  
  277.             fx=tile&fx_mask;
  278.             fy=tile&fy_mask;
  279.             tile=tile&sprite_mask;
  280.             if (tile>0x4fff) continue;
  281.  
  282.             if (flipscreen) {
  283.                 if (fx) fx=0; else fx=1;
  284.                 if (fy) fy=0; else fy=1;
  285.             }
  286.  
  287.             if (color)
  288.                 drawgfx(bitmap,Machine->gfx[1],
  289.                     tile,
  290.                     color,
  291.                     fx,fy,
  292.                     mx,my,
  293.                     0,TRANSPARENCY_PEN,0);
  294.  
  295.             if (flipscreen)
  296.                 my=(my-16)&0x1ff;
  297.             else
  298.                 my=(my+16)&0x1ff;
  299.         }
  300.     }
  301. }
  302.  
  303. void alpha68k_V_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  304. {
  305.     static int last_bank=0;
  306.     int offs,color,i;
  307.     int colmask[256],code,pal_base;
  308.  
  309.     if (last_bank!=bank_base)
  310.         tilemap_mark_all_tiles_dirty(ALL_TILEMAPS);
  311.     last_bank=bank_base;
  312.     tilemap_set_flip(ALL_TILEMAPS,flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  313.     tilemap_update(fix_tilemap);
  314.  
  315.     /* Build the dynamic palette */
  316.     palette_init_used_colors();
  317.     pal_base = Machine->drv->gfxdecodeinfo[1].color_codes_start;
  318.     for (color = 0;color < 256;color++) colmask[color] = 0;
  319.     for (offs = 0x1000;offs <0x4000;offs += 4 )
  320.     {
  321.         color= READ_WORD(&spriteram[offs])&0xff;
  322.         if (!color) continue;
  323.         code = READ_WORD(&spriteram[offs+2])&0x7fff;
  324.         colmask[color] |= Machine->gfx[1]->pen_usage[code];
  325.     }
  326.  
  327.     for (color = 1;color < 256;color++)
  328.     {
  329.         for (i = 1;i < 16;i++)
  330.         {
  331.             if (colmask[color] & (1 << i))
  332.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  333.         }
  334.     }
  335.  
  336.     palette_transparent_color=4095;
  337.     palette_used_colors[4095] = PALETTE_COLOR_USED;
  338.     if (palette_recalc())
  339.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  340.     fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  341.     tilemap_render(ALL_TILEMAPS);
  342.  
  343.     /* This appears to be correct priority */
  344.     if (!strcmp(Machine->gamedrv->name,"skyadvnt")) /* Todo */
  345.     {
  346.         draw_sprites_V(bitmap,0,0x0f80,0x1000,0,0x8000,0x7fff);
  347.         draw_sprites_V(bitmap,1,0x0000,0x1000,0,0x8000,0x7fff);
  348.         draw_sprites_V(bitmap,2,0x0000,0x1000,0,0x8000,0x7fff);
  349.         draw_sprites_V(bitmap,0,0x0000,0x0f80,0,0x8000,0x7fff);
  350.     }
  351.     else    /* gangwars */
  352.     {
  353.         draw_sprites_V(bitmap,0,0x0f80,0x1000,0x8000,0,0x7fff);
  354.         draw_sprites_V(bitmap,1,0x0000,0x1000,0x8000,0,0x7fff);
  355.         draw_sprites_V(bitmap,2,0x0000,0x1000,0x8000,0,0x7fff);
  356.         draw_sprites_V(bitmap,0,0x0000,0x0f80,0x8000,0,0x7fff);
  357.     }
  358.  
  359.     tilemap_draw(bitmap,fix_tilemap,0);
  360. }
  361.  
  362. void alpha68k_V_sb_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  363. {
  364.     int offs,color,tile,i;
  365.     int colmask[256],code,pal_base;
  366.  
  367.     /* Build the dynamic palette */
  368.     memset(palette_used_colors,PALETTE_COLOR_UNUSED,4096 * sizeof(unsigned char));
  369.  
  370.     /* Text layer */
  371.     pal_base = Machine->drv->gfxdecodeinfo[0].color_codes_start;
  372.     for (color = 0;color < 16;color++) colmask[color] = 0;
  373.     for (offs = 0;offs <0x1000;offs += 4)
  374.     {
  375.         color = READ_WORD(&videoram[offs+2])&0xf;
  376.         tile = READ_WORD(&videoram[offs])&0xff;
  377.         tile = tile | ((bank_base)<<8);
  378.         colmask[color] |= Machine->gfx[0]->pen_usage[tile];
  379.     }
  380.     for (color = 0;color < 16;color++)
  381.     {
  382.         for (i = 1;i < 16;i++)
  383.         {
  384.             if (colmask[color] & (1 << i))
  385.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  386.         }
  387.     }
  388.  
  389.     /* Tiles */
  390.     pal_base = Machine->drv->gfxdecodeinfo[1].color_codes_start;
  391.     for (color = 0;color < 256;color++) colmask[color] = 0;
  392.     for (offs = 0x1000;offs <0x4000;offs += 4 )
  393.     {
  394.         color= READ_WORD(&spriteram[offs])&0xff;
  395.         if (!color) continue;
  396.         code = READ_WORD(&spriteram[offs+2])&0x7fff;
  397.         colmask[color] |= Machine->gfx[1]->pen_usage[code];
  398.     }
  399.  
  400.     for (color = 1;color < 256;color++)
  401.     {
  402.         for (i = 1;i < 16;i++)
  403.         {
  404.             if (colmask[color] & (1 << i))
  405.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  406.         }
  407.     }
  408.  
  409.     palette_transparent_color=4095;
  410.     palette_used_colors[4095] = PALETTE_COLOR_USED;
  411.     palette_recalc();
  412.     fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  413.  
  414.     /* This appears to be correct priority */
  415.     draw_sprites_V(bitmap,0,0x0f80,0x1000,0x4000,0x8000,0x3fff);
  416.     draw_sprites_V(bitmap,1,0x0000,0x1000,0x4000,0x8000,0x3fff);
  417.     draw_sprites_V(bitmap,2,0x0000,0x1000,0x4000,0x8000,0x3fff);
  418.     draw_sprites_V(bitmap,0,0x0000,0x0f80,0x4000,0x8000,0x3fff);
  419.  
  420.     tilemap_draw(bitmap,fix_tilemap,0);
  421. }
  422.  
  423. /******************************************************************************/
  424.  
  425. void alpha68k_I_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  426. {
  427.     int i,bit0,bit1,bit2,bit3;
  428.  
  429.     for( i=0; i<256; i++ )
  430.     {
  431.         bit0 = (color_prom[0] >> 0) & 0x01;
  432.         bit1 = (color_prom[0] >> 1) & 0x01;
  433.         bit2 = (color_prom[0] >> 2) & 0x01;
  434.         bit3 = (color_prom[0] >> 3) & 0x01;
  435.         *palette++ = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  436.  
  437.         bit0 = (color_prom[0x100] >> 0) & 0x01;
  438.         bit1 = (color_prom[0x100] >> 1) & 0x01;
  439.         bit2 = (color_prom[0x100] >> 2) & 0x01;
  440.         bit3 = (color_prom[0x100] >> 3) & 0x01;
  441.         *palette++ = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  442.  
  443.         bit0 = (color_prom[0x200] >> 0) & 0x01;
  444.         bit1 = (color_prom[0x200] >> 1) & 0x01;
  445.         bit2 = (color_prom[0x200] >> 2) & 0x01;
  446.         bit3 = (color_prom[0x200] >> 3) & 0x01;
  447.         *palette++ = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  448.  
  449.         color_prom++;
  450.     }
  451. }
  452.  
  453. static void draw_sprites2(struct osd_bitmap *bitmap, int c,int d)
  454. {
  455.     int offs,mx,my,color,tile,i;
  456.  
  457.     for (offs = 0x0000; offs < 0x800; offs += 0x40 )
  458.     {
  459.         mx=READ_WORD(&spriteram[offs+c]);
  460.  
  461.         my=mx>>8;
  462.         mx=mx&0xff;
  463.  
  464.         mx=(mx+0x100)&0x1ff;
  465.         my=(my+0x100)&0x1ff;
  466.         mx-=0x110;
  467.         my-=0x100;
  468.         my=0x200 - my;
  469.         my-=0x200;
  470.  
  471.         for (i=0; i<0x40; i+=2) {
  472.             tile=READ_WORD(&spriteram[offs+d+i]);
  473.             color=1;
  474.             tile&=0x3fff;
  475.  
  476.             if (tile && tile!=0x3000 && tile!=0x26)
  477.                 drawgfx(bitmap,Machine->gfx[0],
  478.                     tile,
  479.                     color,
  480.                     0,0,
  481.                     mx+16,my,
  482.                     0,TRANSPARENCY_PEN,0);
  483.  
  484.             my=(my+8)&0xff;
  485.         }
  486.     }
  487. }
  488.  
  489. void alpha68k_I_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  490. {
  491.     fillbitmap(bitmap,Machine->pens[0],&Machine->drv->visible_area);
  492.  
  493.     /* This appears to be correct priority */
  494. draw_sprites2(bitmap,6,0x1800);
  495. draw_sprites2(bitmap,4,0x1000);
  496. draw_sprites2(bitmap,2,0x800);
  497. //
  498. }
  499.  
  500. /******************************************************************************/
  501.  
  502. void kyros_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  503. {
  504.     int i,bit0,bit1,bit2,bit3;
  505.  
  506.     for (i = 0;i < 256;i++)
  507.     {
  508.         bit0 = (color_prom[0] >> 0) & 0x01;
  509.         bit1 = (color_prom[0] >> 1) & 0x01;
  510.         bit2 = (color_prom[0] >> 2) & 0x01;
  511.         bit3 = (color_prom[0] >> 3) & 0x01;
  512.         *palette++ = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  513.  
  514.         bit0 = (color_prom[0x100] >> 0) & 0x01;
  515.         bit1 = (color_prom[0x100] >> 1) & 0x01;
  516.         bit2 = (color_prom[0x100] >> 2) & 0x01;
  517.         bit3 = (color_prom[0x100] >> 3) & 0x01;
  518.         *palette++ = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  519.  
  520.         bit0 = (color_prom[0x200] >> 0) & 0x01;
  521.         bit1 = (color_prom[0x200] >> 1) & 0x01;
  522.         bit2 = (color_prom[0x200] >> 2) & 0x01;
  523.         bit3 = (color_prom[0x200] >> 3) & 0x01;
  524.         *palette++ = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  525.  
  526.         color_prom++;
  527.     }
  528.  
  529.     color_prom += 0x200;
  530.  
  531.     for (i = 0;i < 256;i++)
  532.     {
  533.         *colortable++ = ((color_prom[0] & 0x0f) << 4) | (color_prom[0x100] & 0x0f);
  534.         color_prom++;
  535.     }
  536. }
  537.  
  538.  
  539. static void kyros_draw_sprites(struct osd_bitmap *bitmap, int c,int d)
  540. {
  541.     int offs,mx,my,color,tile,i,bank,fy;
  542.  
  543.     for (offs = 0x0000; offs < 0x800; offs += 0x40 )
  544.     {
  545.         mx=READ_WORD(&spriteram[offs+c]);
  546.         my=0x100-(mx>>8);
  547.         mx=mx&0xff;
  548.  
  549.         for (i=0; i<0x40; i+=2) {
  550.             tile=READ_WORD(&spriteram[offs+d+i]);
  551.             color=(tile&0x4000)>>14;
  552.             fy=tile&0x1000;
  553.             bank=((tile>>10)&0x3)+((tile&0x8000)?4:0);
  554.             tile=(tile&0x3ff)+((tile&0x2000)?0x400:0);
  555.  
  556.             drawgfx(bitmap,Machine->gfx[bank],
  557.                     tile,
  558.                     color,
  559.                     0,fy,
  560.                     mx,my,
  561.                     0,TRANSPARENCY_PEN,0);
  562.  
  563.             my=(my+8)&0xff;
  564.         }
  565.     }
  566. }
  567.  
  568. void kyros_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  569. {
  570.     fillbitmap(bitmap,Machine->pens[0],&Machine->drv->visible_area);
  571.  
  572.     kyros_draw_sprites(bitmap,4,0x1000);
  573.     kyros_draw_sprites(bitmap,6,0x1800);
  574.     kyros_draw_sprites(bitmap,2,0x800);
  575. }
  576.  
  577. /******************************************************************************/
  578.  
  579. static void sstingry_draw_sprites(struct osd_bitmap *bitmap, int c,int d)
  580. {
  581.     int offs,mx,my,color,tile,i,bank,fx,fy;
  582.  
  583.     for (offs = 0x0000; offs < 0x800; offs += 0x40 )
  584.     {
  585.         mx=READ_WORD(&spriteram[offs+c]);
  586.         my=0x100-(mx>>8);
  587.         mx=mx&0xff;
  588.  
  589.         for (i=0; i<0x40; i+=2) {
  590.             tile=READ_WORD(&spriteram[offs+d+i]);
  591.             color=0; //bit 0x4000
  592.             fy=tile&0x1000;
  593.             fx=0;
  594.             tile=(tile&0xfff);
  595.             bank=tile/0x400;
  596.  
  597.             drawgfx(bitmap,Machine->gfx[bank],
  598.                     tile&0x3ff,
  599.                     color,
  600.                     fx,fy,
  601.                     mx,my,
  602.                     0,TRANSPARENCY_PEN,0);
  603.  
  604.             my=(my+8)&0xff;
  605.         }
  606.     }
  607. }
  608.  
  609. void sstingry_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  610. {
  611.     fillbitmap(bitmap,Machine->pens[0],&Machine->drv->visible_area);
  612.  
  613.     sstingry_draw_sprites(bitmap,4,0x1000);
  614.     sstingry_draw_sprites(bitmap,6,0x1800);
  615.     sstingry_draw_sprites(bitmap,2,0x800);
  616. }
  617.  
  618. /******************************************************************************/
  619.  
  620. static void get_kouyakyu_info( int tile_index )
  621. {
  622.     int offs=tile_index*4;
  623.     int tile=READ_WORD(&videoram[offs])&0xff;
  624.     int color=READ_WORD(&videoram[offs+2])&0xf;
  625.  
  626.     SET_TILE_INFO(0,tile,color)
  627. }
  628.  
  629. WRITE_HANDLER( kouyakyu_video_w )
  630. {
  631.     WRITE_WORD(&videoram[offset],data);
  632.     tilemap_mark_tile_dirty( fix_tilemap, offset/4 );
  633. }
  634.  
  635. int kouyakyu_vh_start(void)
  636. {
  637.     fix_tilemap = tilemap_create(get_kouyakyu_info,tilemap_scan_cols,TILEMAP_TRANSPARENT,8,8,32,32);
  638.  
  639.     if (!fix_tilemap)
  640.         return 1;
  641.  
  642.     fix_tilemap->transparent_pen = 0;
  643.  
  644.     return 0;
  645. }
  646.  
  647. void kouyakyu_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  648. {
  649.     fillbitmap(bitmap,1,&Machine->drv->visible_area);
  650.  
  651. sstingry_draw_sprites(bitmap,4,0x1000);
  652. sstingry_draw_sprites(bitmap,6,0x1800);
  653. sstingry_draw_sprites(bitmap,2,0x800);
  654.  
  655.     tilemap_update(ALL_TILEMAPS);
  656.     tilemap_render(ALL_TILEMAPS);
  657.     tilemap_draw(bitmap,fix_tilemap,0);
  658. }
  659.